package com.tx.studentManager.service;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import net.sf.json.JSONObject;

import org.apache.log4j.Logger;
import org.springframework.transaction.annotation.Transactional;

import com.tx.studentManager.qo.BaseQo;
import com.tx.studentManager.dao.base.HibernateGenericDao;
import com.tx.studentManager.model.BaseModel;
import com.tx.studentManager.model.Page;

@SuppressWarnings({ "unchecked", "rawtypes" })
@Transactional(rollbackFor = RuntimeException.class)
abstract class BaseService<T extends BaseModel, PK extends Serializable, DAO extends HibernateGenericDao, QO extends BaseQo> {
	private Logger logger = Logger.getLogger(StudentService.class);

	abstract protected DAO getDao();

	/**
	 * 根据主键查找唯一对象
	 * 
	 * @param id
	 *            主键
	 * @return 找不到返回null
	 */
	public T findById(PK id) {
		logger.debug("find by id:" + id);
		return (T) getDao().get(id);
	}

	/**
	 * 插入对象
	 * 
	 * @param model
	 * @return 成功返回要插入的对象，失败返回null
	 */
	public T insert(T model) {
		logger.debug("insert into "+getDao().getEntityClass().getSimpleName()+" :"
				+ JSONObject.fromObject(model).toString());
		BaseModel baseModel = getDao().save(model);
		if (baseModel == null) {
			return null;
		}
		return (T) baseModel;
	}

	/**
	 * 查询全部对象
	 * 
	 * @return
	 */
	public List<T> findAll() {
		logger.debug("findAll ");
		return getDao().getAll();
	}

	/**
	 * 根据指定Entity属性及其对应值查找
	 * 
	 * @param propertyName
	 * @param value
	 * @return
	 */
	public List<T> findBy(String propertyName, Object value) {
		logger.debug("find by " + propertyName + ",value:" + value);
		return getDao().findBy(propertyName, value);
	}

	/**
	 * 根据entity删除
	 * 
	 * @param model
	 * @return 成功true，失败false
	 */
	public boolean delete(T model) {
		return getDao().delete(model);
	}
	/**
	 * 
	 * @描述 删除集合内对象
	 * @param list
	 * @return
	 */
	public boolean deleteAll(Collection<T> list){
		try {
			for (T t : list) {
				getDao().delete(t);
			}
		} catch (Exception e) {
			return false;
		}
		return true;
	}
	/**
	 * 根据主键删除对象
	 * 
	 * @param id
	 * @return 成功true，失败false
	 */
	@Transactional
	public boolean delete(PK id) {
		logger.debug("delete " + getDao().getEntityClass().getSimpleName()
				+ " by id:" + id);
		return getDao().delete(id);
	}

	/**
	 * 更新对象
	 * 
	 * @param model
	 * @return
	 */
	public boolean update(T model) {
		return getDao().update(model);
	}

	/**
	 * 根据指定sql查询对象
	 * 
	 * @param sql
	 *            查询的sql
	 * @param objects
	 *            参数
	 * @return
	 */
	public List<T> selectBySql(String sql, Object... objects) {
		List<T> list = getDao().findWithSql(sql, objects);
		return list;
	}

	/**
	 * 
	 * 根据指定sql查询对象
	 * 
	 * @param sql
	 * @param values
	 * @return
	 */
	public List<T> selectBySql(String sql, Map<String, Object> values) {
		List<T> list = getDao().findWithSql(sql, values);
		return list;
	}

	/**
	 * 
	 * 执行删除或更新sql
	 * 
	 * @param sql
	 *            要执行的sql
	 * @param values
	 *            参数
	 * @return 执行更新和删除的entity条数
	 */
	public int batchExecuteWithSql(String sql, Map<String, Object> values) {
		int result = getDao().batchExecuteWithSql(sql, values);
		return result;
	}

	/**
	 * 
	 * 执行删除或更新sql
	 * 
	 * @param sql
	 *            要执行的sql
	 * @param objects
	 *            参数
	 * @return 执行更新和删除的entity条数
	 */
	public int batchExecuteWithSql(String sql, Object... objects) {
		int result = getDao().batchExecuteWithSql(sql, objects);
		return result;
	}

	/**
	 * 
	 * 按照Hql查询
	 * 
	 * @param hql
	 * @param values
	 * @return
	 */
	public int batchExecuteWithHql(String hql, Object... values) {
		return getDao().batchExecuteWithHql(hql, values);
	}

	/**
	 * 
	 * 按照Hql查询
	 * 
	 * @param hql
	 * @param values
	 * @return
	 */
	public int batchExecuteWithHql(String hql, Map<String, Object> values) {
		return getDao().batchExecuteWithHql(hql, values);
	}

	/**
	 * 根据hql查询对象
	 * 
	 * @param hql
	 * @param values
	 * @return
	 */
	public List<T> selectByHQL(final String hql,
			final Map<String, Object> values) {
		return getDao().findWithHQL(hql, values);
	}

	/**
	 * 根据hql查询对象
	 * 
	 * @param hql
	 * @param values
	 * @return
	 */
	public List<T> selectByHQL(final String hql, final Object... values) {
		return getDao().findWithHQL(hql, values);
	}

	/**
	 * 根据实体example查询
	 * 
	 * @param example
	 * @return
	 */
	public List<T> list(T example) {
		return getDao().queryList(example);
	}

	/**
	 * 载入对象，获取的只是代理，要获取
	 * 
	 * @param id
	 * @return
	 */
	public T load(PK id) {
		return (T) getDao().load(id);
	}

	public List<T> list(QO qo) {
		return getDao().queryList(qo);
	}

	/**
	 * 
	 * 根据分页参数查询
	 * 
	 * @param page
	 * @return
	 */
	public Page list(Page page) {
		return getDao().queryListByPage(page);
	}
	
	/**
	 * 
	* 根据指定属性值查询唯一对象
	* @param propertyName 属性名
	* @param value 属性值
	* @return
	 */
	public T findUniqueBy(String propertyName,Object value){
		return (T) getDao().findUniqueBy(propertyName, value);
	}
}
